package net.hn.hnms.biz.analysis.utils;

public class WaterRuleUtil {

    /**
     * 计算电阻率得分
     *
     * @param resistivity 电阻率值
     * @return 得分（float 类型）
     */
    public static float getResistivityScores(float resistivity) {
        float result = 0;
        // 计算 p 值，并保留 4 位小数
        float p = (float) Math.round(((resistivity - 10) / 10) * 10000) / 10000;

        // 根据 p 值范围计算结果
        if (p < 0.25) {
            result = 1;
        } else if (p >= 0.25 && p < 0.5) {
            result = 0.84f;
        } else if (p >= 0.5 && p < 0.75) {
            result = 0.75f;
        } else if (p >= 0.75 && p < 1) {
            result = 0.59f;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算长观孔水温度得分
     *
     * @param temperature 温度值
     * @return 得分（float 类型）
     */
    public static float getLongholeViewWaterTemperatureScores(float temperature) {
        float result = 0;
        // 计算 v 值，取绝对值
        float v = Math.abs(temperature - 10);

        // 根据 v 值范围计算结果
        if (v < 2) {
            result = 1;
        } else if (v >= 2 && v < 4) {
            result = 0.84f;
        } else if (v >= 4 && v < 6) {
            result = 0.75f;
        } else if (v >= 6 && v < 10) {
            result = 0.59f;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算长观孔水位得分
     *
     * @param waterLevel 水位值
     * @return 得分（float 类型）
     */
    public static float getLongholeViewWaterLevelScores(float waterLevel) {
        float result = 0;
        // 计算 v 值，取绝对值
        float v = Math.abs(waterLevel - 10);

        // 根据 v 值范围计算结果
        if (v < 2) {
            result = 1;
        } else if (v >= 2 && v < 4) {
            result = 0.84f;
        } else if (v >= 4 && v < 6) {
            result = 0.75f;
        } else if (v >= 6 && v < 10) {
            result = 0.59f;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算密闭墙水温度得分
     *
     * @param temperature 温度值
     * @return 得分（float 类型）
     */
    public static float getForbiddenWallWaterTemperatureScores(float temperature) {
        float result = 0;
        // 计算 v 值，取绝对值
        float v = Math.abs(temperature - 10);

        // 根据 v 值范围计算结果
        if (v < 2) {
            result = 1;
        } else if (v >= 2 && v < 4) {
            result = 0.84f;
        } else if (v >= 4 && v < 6) {
            result = 0.75f;
        } else if (v >= 6 && v < 10) {
            result = 0.59f;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算密闭墙水位得分
     *
     * @param waterLevel 水位值
     * @return 得分（float 类型）
     */
    public static float getForbiddenWallWaterLevelScores(float waterLevel) {
        float result = 0;
        // 计算 v 值，取绝对值
        float v = Math.abs(waterLevel - 10);
        // 根据 v 值范围计算结果
        if (v < 2) {
            result = 1;
        } else if (v >= 2 && v < 4) {
            result = 0.84f;
        } else if (v >= 4 && v < 6) {
            result = 0.75f;
        } else if (v >= 6 && v < 10) {
            result = 0.59f;
        }
        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算日累计排水量得分
     *
     * @param waterOutput   日排水量
     * @param baseDrainData 基础排水量
     * @return 得分（float 类型）
     */
    public static float getDailyCumulativeDischarge(float waterOutput, float baseDrainData) {
        float result = 0;

        // 如果基础排水量为 0，直接返回固定值
        if (baseDrainData == 0) {
            return 80;
        }

        // 计算 p 值，并保留 4 位小数
        float p = Math.round(((waterOutput - baseDrainData) / baseDrainData) * 10000) / 10000.0f;

        // 根据 p 值范围计算结果
        if (p < 0.6) {
            result = 1;
        } else if (p >= 0.6 && p < 0.7) {
            result = 0.84f;
        } else if (p >= 0.7 && p < 0.8) {
            result = 0.75f;
        } else if (p > 0.8 && p < 0.9) {
            result = 0.59f;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算日最大涌水量得分
     *
     * @param waterOutput 日最大涌水量
     * @return 得分（float 类型）
     */
    public static float getMaxWaterInflow(Float waterOutput) {
        float result = 0;

        // 如果 waterOutput 为 null 或等于 0，直接返回固定值
        if (waterOutput == null || waterOutput == 0) {
            return 80;
        }

        // 计算 p 值，并保留 4 位小数
        float p = Math.round(((waterOutput - 140) / 140.0f) * 10000) / 10000.0f;

        // 根据 p 值范围计算结果
        if (p < 0.6) {
            result = 1;
        } else if (p >= 0.6 && p < 0.7) {
            result = 0.84f;
        } else if (p >= 0.7 && p < 0.8) {
            result = 0.75f;
        } else if (p > 0.8 && p < 0.9) {
            result = 0.59f;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算水文地质类型得分
     *
     * @param hydroType 水文地质类型（1: 简单, 2: 中等, 3: 复杂, 4: 极复杂）
     * @return 得分（float 类型）
     */
    public static float getHydrogeologicalTypeScores(int hydroType) {
        float result = 0;

        // 根据 hydroType 的值计算结果
        if (hydroType == 1) {
            result = 1;
        } else if (hydroType == 2) {
            result = 0.85f;
        } else if (hydroType == 3) {
            result = 0.7f;
        } else if (hydroType == 4) {
            result = 0.6f;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算是否有地表水的得分
     *
     * @param isExist 是否有地表水（0: 无, 非0: 有）
     * @return 得分（float 类型）
     */
    public static float getFloorWaterScores(int isExist) {
        float result = 0;

        // 如果 isExist 等于 0，设置结果为 1
        if (isExist == 0) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算是否有断裂构造水和岩溶水的得分
     *
     * @param isExist 是否有断裂构造水和岩溶水（0: 无, 非0: 有）
     * @return 得分（float 类型）
     */
    public static float getFaultStructuralAndKarstWaterScores(int isExist) {
        float result = 0;

        // 如果 isExist 等于 0，设置结果为 1
        if (isExist == 0) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算是否有老空水的得分
     *
     * @param isExist 是否有老空水（0: 无, 非0: 有）
     * @return 得分（float 类型）
     */
    public static float getWaterEmpty(int isExist) {
        float result = 0;

        // 如果 isExist 等于 0，设置结果为 1
        if (isExist == 0) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算是否编制防止水年度计划的得分
     *
     * @param isReady 是否编制防止水年度计划（true: 已编制, false: 未编制）
     * @return 得分（float 类型）
     */
    public static float getAnnualWaterControlPlanScores(int isReady) {
        float result = 0;

        // 如果 isReady 为 true，设置结果为 1
        if (isReady == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算是否编制防治水中长期计划的得分
     *
     * @param isReady 是否编制防治水中长期计划（true: 已编制, false: 未编制）
     * @return 得分（float 类型）
     */
    public static float getLongTermWaterControlPlanScores(int isReady) {
        float result = 0;

        // 如果 isReady 为 true，设置结果为 1
        if (isReady == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算是否设置防治水机构的得分
     *
     * @param isReady 是否设置防治水机构（true: 已设置, false: 未设置）
     * @return 得分（float 类型）
     */
    public static float getWaterControlOrganizationScores(int isReady) {
        float result = 0;

        // 如果 isReady 为 true，设置结果为 1
        if (isReady == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算煤矿水害台账完整率得分
     *
     * @param percent 煤矿水害台账完整率（百分比）
     * @return 得分（float 类型）
     */
    public static float getIntegrityRateOfCoalMineWaterHazardAccountScores(float percent) {
        float result = 0;

        // 根据百分比范围计算结果
        if (percent > 85 && percent < 95) {
            result = Math.round(((percent - 85) / 10) * 10000) / 100.0f; // 保留 4 位小数
        } else if (percent >= 95) {
            result = 100;
        }

        // 返回最终得分
        return result;
    }

    /**
     * 计算本月是否开展水害隐患排查的得分
     *
     * @param isReady 本月是否开展水害隐患排查（true: 已开展, false: 未开展）
     * @return 得分（float 类型）
     */
    public static float getInvestigationWaterHazardsByMonth(int isReady) {
        float result = 0;

        // 如果 isReady 为 true，设置结果为 1
        if (isReady == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算本年度是否进行水害应急救援演练的得分
     *
     * @param isReady 本年度是否进行水害应急救援演练（true: 已进行, false: 未进行）
     * @return 得分（float 类型）
     */
    public static float getWaterDisasterEmergencyRescueByYearScores(int isReady) {
        float result = 0;

        // 如果 isReady 为 true，设置结果为 1
        if (isReady == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算是否配备防治水副总工程师的得分
     *
     * @param isEquip 是否配备防治水副总工程师（1: 已配备, 非1: 未配备）
     * @return 得分（float 类型）
     */
    public static float getChiefWaterControlPreventionEngineerScores(int isEquip) {
        float result = 0;

        // 如果 isEquip 等于 1，设置结果为 1
        if (isEquip == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算防治水人员数量的得分
     *
     * @param staffCount 防治水人员数量
     * @return 得分（float 类型）
     */
    public static float getWaterControlStaffCountScores(int staffCount) {
        float result = 0;

        // 根据防治水人员数量范围计算结果
        if (staffCount >= 3 && staffCount < 9) {
            result = Math.round(((staffCount - 3) / 6.0f) * 10000) / 10000.0f; // 保留 4 位小数
        } else if (staffCount >= 9) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算是否有探水队伍的得分
     *
     * @param isEquip 是否有探水队伍（1: 有, 非1: 无）
     * @return 得分（float 类型）
     */
    public static float getWaterExplorationTeamScores(int isEquip) {
        float result = 0;

        // 如果 isEquip 等于 1，设置结果为 1
        if (isEquip == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算防水知识培训率的得分
     *
     * @param trainingPercent 防水知识培训率（百分比）
     * @return 得分（float 类型）
     */
    public static float getWaterPreventionTrainingPercentScores(float trainingPercent) {
        float result = 0;

        // 根据培训率范围计算结果
        if (trainingPercent > 85 && trainingPercent < 95) {
            result = Math.round(((trainingPercent - 85) / 10) * 10000) / 10000.0f; // 保留 4 位小数
        } else if (trainingPercent >= 95) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算是否配备探水装备的得分
     *
     * @param isEquip 是否配备探水装备（1: 已配备, 非1: 未配备）
     * @return 得分（float 类型）
     */
    public static float getWaterExplorationEquipmentScores(int isEquip) {
        float result = 0;

        // 如果 isEquip 等于 1，设置结果为 1
        if (isEquip == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算正常泵能力是否满足要求的得分
     *
     * @param isEquip 正常泵能力是否满足要求（1: 满足, 非1: 不满足）
     * @return 得分（float 类型）
     */
    public static float getNormalPumpCapacityScores(int isEquip) {
        float result = 0;

        // 如果 isEquip 等于 1，设置结果为 1
        if (isEquip == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }

    /**
     * 计算备用泵能力是否满足要求的得分
     *
     * @param isEquip 备用泵能力是否满足要求（1: 满足, 非1: 不满足）
     * @return 得分（float 类型）
     */
    public static float getPreparedPumpCapacityScores(int isEquip) {
        float result = 0;

        // 如果 isEquip 等于 1，设置结果为 1
        if (isEquip == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }
    /**
     * 计算检修泵能力是否具备的得分
     *
     * @param isEquip 检修泵能力是否具备（1: 具备, 非1: 不具备）
     * @return 得分（float 类型）
     */
    public static float getRepairPumpCapacityScores(int isEquip) {
        float result = 0;

        // 如果 isEquip 等于 1，设置结果为 1
        if (isEquip == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }
    /**
     * 计算排水管路能力是否满足要求的得分
     *
     * @param isEquip 排水管路能力是否满足要求（1: 满足, 非1: 不满足）
     * @return 得分（float 类型）
     */
    public static float getDrainagePipelineCapacityScores(int isEquip) {
        float result = 0;

        // 如果 isEquip 等于 1，设置结果为 1
        if (isEquip == 1) {
            result = 1;
        }

        // 返回最终得分
        return 100 * result;
    }



}
